package com.budweiser.commons.utils;

import org.apache.commons.lang3.StringUtils;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Random;

public class Utils {
	public static List<Long> getLongs(String ids) {
		List<Long> idList = null;
		if (StringUtils.isNotBlank(ids)) {
			idList = new ArrayList<Long>();
			String strList[] = StringUtils.split(ids, ",");
			for (String str : strList) {
				idList.add(Long.parseLong(str));
			}
		}
		return idList;
	}

	public static String[] getStrArarry(String text) {
		if (StringUtils.isNotEmpty(text)) {
			return StringUtils.split(text, ",");
		}
		return null;
	}

	public static int getInt(String object) {
		if (StringUtils.isNotEmpty(object)) {
			return Integer.parseInt(object);
		}
		return 0;
	}

	public static Long toLong(String str) {
		if (StringUtils.isNotEmpty(str)) {
			return Long.parseLong(str);
		}
		return null;
	}

	// 默认除法运算精度
	private static final Integer DEF_DIV_SCALE = 2;

	/**
	 * 提供精确的加法运算。
	 *
	 * @param value1
	 *            被加数
	 * @param value2
	 *            加数
	 * @return 两个参数的和
	 */
	public static Double add(Double value1, Double value2) {
		BigDecimal b1 = new BigDecimal(Double.toString(value1));
		BigDecimal b2 = new BigDecimal(Double.toString(value2));
		return b1.add(b2).doubleValue();
	}

	/**
	 * 提供精确的减法运算。
	 *
	 * @param value1
	 *            被减数
	 * @param value2
	 *            减数
	 * @return 两个参数的差
	 */
	public static double sub(Double value1, Double value2) {
		BigDecimal b1 = new BigDecimal(Double.toString(value1));
		BigDecimal b2 = new BigDecimal(Double.toString(value2));
		return b1.subtract(b2).doubleValue();
	}

	/**
	 * 提供精确的乘法运算。
	 *
	 * @param value1
	 *            被乘数
	 * @param value2
	 *            乘数
	 * @return 两个参数的积
	 */
	public static Double mul(Double value1, Double value2) {
		BigDecimal b1 = new BigDecimal(Double.toString(value1));
		BigDecimal b2 = new BigDecimal(Double.toString(value2));
		return b1.multiply(b2).doubleValue();
	}

	/**
	 * 57 * 提供（相对）精确的除法运算，当发生除不尽的情况时， 精确到小数点以后10位，以后的数字四舍五入。 58 * 59 * @param
	 * dividend 被除数 60 * @param divisor 除数 61 * @return 两个参数的商 62
	 */
	public static Double divide(Double dividend, Double divisor) {
		return divide(dividend, divisor, DEF_DIV_SCALE);
	}

	/**
	 * 68 * 提供（相对）精确的除法运算。 当发生除不尽的情况时，由scale参数指定精度，以后的数字四舍五入。 69 * 70 * @param
	 * dividend 被除数 71 * @param divisor 除数 72 * @param scale 表示表示需要精确到小数点以后几位。
	 * 73 * @return 两个参数的商 74
	 */
	public static Double divide(Double dividend, Double divisor, Integer scale) {
		if (scale < 0) {
			throw new IllegalArgumentException("The scale must be a positive integer or zero");
		}
		BigDecimal b1 = new BigDecimal(Double.toString(dividend));
		BigDecimal b2 = new BigDecimal(Double.toString(divisor));
		return b1.divide(b2, scale, RoundingMode.HALF_UP).doubleValue();
	}

	/**
	 * 提供指定数值的（精确）小数位四舍五入处理。 86 * 87 * @param value 需要四舍五入的数字 88 * @param scale
	 * 小数点后保留几位 89 * @return 四舍五入后的结果 90
	 */
	public static double round(double value, int scale) {
		if (scale < 0) {
			throw new IllegalArgumentException("The scale must be a positive integer or zero");
		}
		BigDecimal b = new BigDecimal(Double.toString(value));
		BigDecimal one = new BigDecimal("1");
		return b.divide(one, scale, RoundingMode.HALF_UP).doubleValue();
	}

	/****
	 * 补0加1
	 * 
	 * @param str
	 * @param strLength
	 * @return
	 */
	public static String addZeroForNum(int str, int strLength) {
		return String.format("%0" + strLength + "d", str + 1);
	}

	/****
	 * 补零
	 * 
	 * @param str
	 * @param strLength
	 * @return
	 */
	public static String addZeroNum(int str, int strLength) {
		return String.format("%0" + strLength + "d", str);
	}

	public static String getRandom(int length) {
		String val = "";
		Random random = new Random();
		for (int i = 0; i < length; i++) {
			val += String.valueOf(random.nextInt(10));
		}
		return val;
	}

	public static String getString(Object obj) {
		if (obj != null) {
			return obj.toString();
		}
		return "";
	}

	public static String strSubstring(String str, String format) {
		if (StringUtils.isNotBlank(str)) {
			str = str.substring(0, str.indexOf(format));
			return str;
		}
		return null;
	}

	public static Double null2Double(Object object) {
		if (object != null) {
			return Double.parseDouble(object.toString());
		}
		return null;
	}

	public static Date null2Date(Object object, String format) {
		try {
			String strDate = getString(object);
			if (StringUtils.isNotBlank(strDate)) {
				SimpleDateFormat formatter = new SimpleDateFormat(format);
				return formatter.parse(strDate);
			}
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return null;
	}

	@SuppressWarnings("deprecation")
	public static Date null2Date(Object object) {
		try {
			String strDate = getString(object);
			if (StringUtils.isNotBlank(strDate)) {
				return new Date(strDate);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	/****
	 * 当天日期
	 * 
	 * @param format
	 * @return
	 */
	public static String getToday(String format) {
		return new SimpleDateFormat(format).format(new Date()).toString();
	}

	/****
	 * 截取后多少位
	 * 
	 * @param str
	 * @param length
	 * @return
	 */
	public static String null2subStrh(String str, int length) {
		if (StringUtils.isNotEmpty(str) && str.length() > length) {
			return str.substring(str.length() - length);
		}
		return null;
	}

	public static void main(String[] args) {
		String xx = addZeroForNum(1, 2);
		System.out.println(xx);
	}
}
